COMMENT ⊗   VALID 00002 PAGES
C REC  PAGE   DESCRIPTION
C00001 00001
C00002 00002	The following macros facilitate writing machine language
C00014 ENDMK
C⊗;
comment The following macros facilitate writing machine language
code to be compiled at run time by a SAIL program.;

comment See ASSEMB.TXT[DOC,PB] for more explanation on how to use this stuff;

REQUIRE "{}<>" DELIMITERS;
REDEFINE LOC={LOCATION};

comment The following LET's redefine the given SAIL reserved words to have
an appended "F" to distinguish them from the macros below so that the latter
have the usual mnemonics.  These obey scope rules, so this file should be
required in a local block;


LET IBPF=IBP;
LET IDPBF=IDPB;
LET ILDBF=ILDB;
LET LDBF=LDB;
LET LSHF=LSH;
LET ROTF=ROT;

comment Note that in the following macros, if Y < 0  or Y has more than 18 bits,
the macro will not behave as desired.  To take only the right half of Y, use
HR(Y).  This is not done automatically by the macros so that the indirect bit
can be set by in(Y) being used as the address argument.:

DEFINE makop(op,opcode)=
{DEFINE op(A,Y)={'}&{opcode}&{000000000 LOR (A LSHF 23) LOR (Y)}};
DEFINE ADD  (A,Y)={'270000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE ADDI (A,Y)={'271000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE ADDM (A,Y)={'272000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE ADJBP(A,Y)={'133000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE AOBJN(A,Y)={'253000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE AOJ  (A,Y)={'340000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE AOS  (A,Y)={'350000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE BLT  (A,Y)={'251000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAIE(A,Y) ={'302000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAIGE(A,Y)={'305000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAIL (A,Y)={'301000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAILE(A,Y)={'303000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAMG (A,Y)={'317000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAML(A,Y) ={'311000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE CAMLE(A,Y)={'313000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE DPB(A,Y)  ={'137000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE HRLZI(A,Y)={'515000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE HRRI(A,Y) ={'541000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE IBP(A,Y)  ={'133000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE IDIVI(A,Y)={'231000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE IDPB(A,Y) ={'136000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE ILDB(A,Y) ={'134000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE IMUL(A,Y) ={'220000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE IMULI(A,Y)={'221000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE JRST (A,Y)={'254000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE JUMPE(A,Y)={'322000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE JUMPN(A,Y)={'326000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE LDB(A,Y)  ={'135000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE LSH(A,Y)  ={'242000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVE(A,Y) ={'200000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVEI(A,Y)={'201000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVEM(A,Y)={'202000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVN(A,Y) ={'210000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVS(A,Y) ={'204000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE MOVSI(A,Y)={'205000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE POPJ(A,Y) ={'263000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE ROT (A,Y) ={'241000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE SETZ(A,Y) ={'400000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE SETZM(A,Y)={'402000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE SOJG(A,Y) ={'367000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE SUB(A,Y)  ={'274000000000 LOR (A LSHF 23) LOR (Y)};
DEFINE SUBI(A,Y) ={'275000000000 LOR (A LSHF 23) LOR (Y)};

DEFINE BIT(N)={(1 ROTF -(N+1))};	! 1 in bit pos N, counting from 0 from left;
DEFINE in(Y)={(BIT(13) LOR (Y))};	! set indirect bit;
DEFINE IX(R)={LOR (R ROTF -(17+1))};	! index register;
DEFINE HR(Y)={('777777 LAND (Y))};	! right half of Y--essential if Y negative;
DEFINE CBLK$_BEGIN(n)=			! start a code block;
       {BEGIN "CBLK$} & {n} & {"} &	! BEGIN "CBLK$n";
       { DEFINE i$n={i$} & {n}; } &	! i$←←i$n;
       {INTEGER i$n;
	OWN INTEGER ARRAY code$[0:10000];};	! assume sys will init i$n to 0;
DEFINE CBLK$_END(n)={END "CBLK$} & {n} & {"};	! end a code block;
DEFINE LABEL$(string)={INTEGER string};	! declare labels = declare ints;
DEFINE C$={code$[i$n←i$n+1]←};	! program counter for generating inline code;
DEFINE L$(label)={label←location(code$[i$n+1]);};	! +1 since u say itb4 C$;
DEFINE c$savac(word0)={
  C$              movem   ('17,   loc(word0)+'17);
  C$              movei   ('17,   loc(word0));
  C$              blt     ('17,   loc(word0)+'16);};	! save registers incl P;
DEFINE c$restac(word0)={
  C$              movsi   ('17,   loc(word0));
  C$              blt     ('17,   '17);};  ! restore registers incl P;

REQUIRE UNSTACK_DELIMITERS;